home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / DatabaseAccess.p < prev    next >
Text File  |  1996-05-01  |  11KB  |  312 lines
  1. {
  2.      File:        DatabaseAccess.p
  3.  
  4.      Contains:    Database Access Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT DatabaseAccess;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __DATABASEACCESS__}
  28. {$SETC __DATABASEACCESS__ := 1}
  29.  
  30. {$I+}
  31. {$SETC DatabaseAccessIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __RESOURCES__}
  35. {$I Resources.p}
  36. {$ENDC}
  37.  
  38. {$PUSH}
  39. {$ALIGN MAC68K}
  40. {$LibExport+}
  41.  
  42. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  43. {  data type codes  }
  44.  
  45. CONST
  46.     typeNone                    = 'none';
  47.     typeDate                    = 'date';
  48.     typeTime                    = 'time';
  49.     typeTimeStamp                = 'tims';
  50.     typeDecimal                    = 'deci';
  51.     typeMoney                    = 'mone';
  52.     typeVChar                    = 'vcha';
  53.     typeVBin                    = 'vbin';
  54.     typeLChar                    = 'lcha';
  55.     typeLBin                    = 'lbin';
  56.     typeDiscard                    = 'disc';                        {  "dummy" types for DBResultsToText  }
  57.     typeUnknown                    = 'unkn';
  58.     typeColBreak                = 'colb';
  59.     typeRowBreak                = 'rowb';                        {  pass this in to DBGetItem for any data type  }
  60.     typeAnyType                    = 0;
  61.  
  62. {  infinite timeout value for DBGetItem  }
  63.                                                                 {  messages for status functions for DBStartQuery  }
  64.     kDBUpdateWind                = 0;
  65.     kDBAboutToInit                = 1;
  66.     kDBInitComplete                = 2;
  67.     kDBSendComplete                = 3;
  68.     kDBExecComplete                = 4;
  69.     kDBStartQueryComplete        = 5;
  70.  
  71.                                                                 {  messages for status functions for DBGetQueryResults  }
  72.     kDBGetItemComplete            = 6;
  73.     kDBGetQueryResultsComplete    = 7;
  74.     kDBWaitForever                = -1;                            {   flags for DBGetItem   }
  75.     kDBLastColFlag                = $0001;
  76.     kDBNullFlag                    = $0004;
  77.  
  78.  
  79. TYPE
  80.     DBType                                = OSType;
  81.     DBAsyncParamBlockRecPtr = ^DBAsyncParamBlockRec;
  82.     DBAsyncParmBlkPtr                    = ^DBAsyncParamBlockRec;
  83.     DBCompletionProcPtr = Register68kProcPtr;  { PROCEDURE DBCompletion(pb: DBAsyncParmBlkPtr); }
  84.  
  85.     DBCompletionUPP = UniversalProcPtr;
  86. {  structure for asynchronous parameter block  }
  87.     DBAsyncParamBlockRec = RECORD
  88.         completionProc:            DBCompletionUPP;                        {  pointer to completion routine  }
  89.         result:                    OSErr;                                    {  result of call  }
  90.         userRef:                LONGINT;                                {  for application's use  }
  91.         ddevRef:                LONGINT;                                {  for ddev's use  }
  92.         reserved:                LONGINT;                                {  for internal use  }
  93.     END;
  94.  
  95. {  structure for resource list in QueryRecord  }
  96.     ResListElemPtr = ^ResListElem;
  97.     ResListElem = RECORD
  98.         theType:                ResType;                                {  resource type  }
  99.         id:                        INTEGER;                                {  resource id  }
  100.     END;
  101.  
  102.     ResListPtr                            = ^ResListElem;
  103.     ResListHandle                        = ^ResListPtr;
  104. {  structure for query list in QueryRecord  }
  105.     QueryArray                            = ARRAY [0..255] OF Handle;
  106.     QueryListPtr                        = ^QueryArray;
  107.     QueryListHandle                        = ^QueryListPtr;
  108.     QueryRecordPtr = ^QueryRecord;
  109.     QueryRecord = RECORD
  110.         version:                INTEGER;                                {  version  }
  111.         id:                        INTEGER;                                {  id of 'qrsc' this came from  }
  112.         queryProc:                Handle;                                    {  handle to query def proc  }
  113.         ddevName:                Str63;                                    {  ddev name  }
  114.         host:                    Str255;                                    {  host name  }
  115.         user:                    Str255;                                    {  user name  }
  116.         password:                Str255;                                    {  password  }
  117.         connStr:                Str255;                                    {  connection string  }
  118.         currQuery:                INTEGER;                                {  index of current query  }
  119.         numQueries:                INTEGER;                                {  number of queries in list  }
  120.         queryList:                QueryListHandle;                        {  handle to array of handles to text  }
  121.         numRes:                    INTEGER;                                {  number of resources in list  }
  122.         resList:                ResListHandle;                            {  handle to array of resource list elements  }
  123.         dataHandle:                Handle;                                    {  for use by query def proc  }
  124.         refCon:                    LONGINT;                                {  for use by application  }
  125.     END;
  126.  
  127.     QueryPtr                            = ^QueryRecord;
  128.     QueryHandle                            = ^QueryPtr;
  129. {  structure of column types array in ResultsRecord  }
  130.     ColTypesArray                        = ARRAY [0..255] OF DBType;
  131.     ColTypesPtr                            = ^ColTypesArray;
  132.     ColTypesHandle                        = ^ColTypesPtr;
  133. {  structure for column info in ResultsRecord  }
  134.     DBColInfoRecordPtr = ^DBColInfoRecord;
  135.     DBColInfoRecord = RECORD
  136.         len:                    INTEGER;
  137.         places:                    INTEGER;
  138.         flags:                    INTEGER;
  139.     END;
  140.  
  141.     ColInfoArray                        = ARRAY [0..255] OF DBColInfoRecord;
  142.     ColInfoPtr                            = ^ColInfoArray;
  143.     ColInfoHandle                        = ^ColInfoPtr;
  144. {  structure of results returned by DBGetResults  }
  145.     ResultsRecordPtr = ^ResultsRecord;
  146.     ResultsRecord = RECORD
  147.         numRows:                INTEGER;                                {  number of rows in result  }
  148.         numCols:                INTEGER;                                {  number of columns per row  }
  149.         colTypes:                ColTypesHandle;                            {  data type array  }
  150.         colData:                Handle;                                    {  actual results  }
  151.         colInfo:                ColInfoHandle;                            {  DBColInfoRecord array  }
  152.     END;
  153.  
  154.     DBQueryDefProcPtr = ProcPtr;  { FUNCTION DBQueryDef(VAR sessID: LONGINT; query: QueryHandle): OSErr; }
  155.  
  156.     DBStatusProcPtr = ProcPtr;  { FUNCTION DBStatus(message: INTEGER; result: OSErr; dataLen: INTEGER; dataPlaces: INTEGER; dataFlags: INTEGER; dataType: DBType; dataPtr: Ptr): BOOLEAN; }
  157.  
  158.     DBResultHandlerProcPtr = ProcPtr;  { FUNCTION DBResultHandler(dataType: DBType; theLen: INTEGER; thePlaces: INTEGER; theFlags: INTEGER; theData: Ptr; theText: Handle): OSErr; }
  159.  
  160.     DBQueryDefUPP = UniversalProcPtr;
  161.     DBStatusUPP = UniversalProcPtr;
  162.     DBResultHandlerUPP = UniversalProcPtr;
  163.  
  164. CONST
  165.     uppDBCompletionProcInfo = $0000B802;
  166.     uppDBQueryDefProcInfo = $000003E0;
  167.     uppDBStatusProcInfo = $000FAA90;
  168.     uppDBResultHandlerProcInfo = $0003EAE0;
  169.  
  170. FUNCTION NewDBCompletionProc(userRoutine: DBCompletionProcPtr): DBCompletionUPP;
  171.     {$IFC NOT GENERATINGCFM }
  172.     INLINE $2E9F;
  173.     {$ENDC}
  174.  
  175. FUNCTION NewDBQueryDefProc(userRoutine: DBQueryDefProcPtr): DBQueryDefUPP;
  176.     {$IFC NOT GENERATINGCFM }
  177.     INLINE $2E9F;
  178.     {$ENDC}
  179.  
  180. FUNCTION NewDBStatusProc(userRoutine: DBStatusProcPtr): DBStatusUPP;
  181.     {$IFC NOT GENERATINGCFM }
  182.     INLINE $2E9F;
  183.     {$ENDC}
  184.  
  185. FUNCTION NewDBResultHandlerProc(userRoutine: DBResultHandlerProcPtr): DBResultHandlerUPP;
  186.     {$IFC NOT GENERATINGCFM }
  187.     INLINE $2E9F;
  188.     {$ENDC}
  189.  
  190. PROCEDURE CallDBCompletionProc(pb: DBAsyncParmBlkPtr; userRoutine: DBCompletionUPP);
  191.     {$IFC NOT GENERATINGCFM}
  192.     {To be implemented:  Glue to move parameters into registers.}
  193.     {$ENDC}
  194.  
  195. FUNCTION CallDBQueryDefProc(VAR sessID: LONGINT; query: QueryHandle; userRoutine: DBQueryDefUPP): OSErr;
  196.     {$IFC NOT GENERATINGCFM}
  197.     INLINE $205F, $4E90;
  198.     {$ENDC}
  199.  
  200. FUNCTION CallDBStatusProc(message: INTEGER; result: OSErr; dataLen: INTEGER; dataPlaces: INTEGER; dataFlags: INTEGER; dataType: DBType; dataPtr: Ptr; userRoutine: DBStatusUPP): BOOLEAN;
  201.     {$IFC NOT GENERATINGCFM}
  202.     INLINE $205F, $4E90;
  203.     {$ENDC}
  204.  
  205. FUNCTION CallDBResultHandlerProc(dataType: DBType; theLen: INTEGER; thePlaces: INTEGER; theFlags: INTEGER; theData: Ptr; theText: Handle; userRoutine: DBResultHandlerUPP): OSErr;
  206.     {$IFC NOT GENERATINGCFM}
  207.     INLINE $205F, $4E90;
  208.     {$ENDC}
  209. FUNCTION InitDBPack: OSErr;
  210.     {$IFC NOT GENERATINGCFM}
  211.     INLINE $3F3C, $0004, $303C, $0100, $A82F;
  212.     {$ENDC}
  213. FUNCTION DBInit(VAR sessID: LONGINT; ddevName: Str63; host: Str255; user: Str255; passwd: Str255; connStr: Str255; asyncPB: DBAsyncParmBlkPtr): OSErr;
  214.     {$IFC NOT GENERATINGCFM}
  215.     INLINE $303C, $0E02, $A82F;
  216.     {$ENDC}
  217. FUNCTION DBEnd(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  218.     {$IFC NOT GENERATINGCFM}
  219.     INLINE $303C, $0403, $A82F;
  220.     {$ENDC}
  221. FUNCTION DBGetConnInfo(sessID: LONGINT; sessNum: INTEGER; VAR returnedID: LONGINT; VAR version: LONGINT; VAR ddevName: Str63; VAR host: Str255; VAR user: Str255; VAR network: Str255; VAR connStr: Str255; VAR start: LONGINT; VAR state: OSErr; asyncPB: DBAsyncParmBlkPtr): OSErr;
  222.     {$IFC NOT GENERATINGCFM}
  223.     INLINE $303C, $1704, $A82F;
  224.     {$ENDC}
  225. FUNCTION DBGetSessionNum(sessID: LONGINT; VAR sessNum: INTEGER; asyncPB: DBAsyncParmBlkPtr): OSErr;
  226.     {$IFC NOT GENERATINGCFM}
  227.     INLINE $303C, $0605, $A82F;
  228.     {$ENDC}
  229. FUNCTION DBSend(sessID: LONGINT; text: Ptr; len: INTEGER; asyncPB: DBAsyncParmBlkPtr): OSErr;
  230.     {$IFC NOT GENERATINGCFM}
  231.     INLINE $303C, $0706, $A82F;
  232.     {$ENDC}
  233. FUNCTION DBSendItem(sessID: LONGINT; dataType: DBType; len: INTEGER; places: INTEGER; flags: INTEGER; buffer: UNIV Ptr; asyncPB: DBAsyncParmBlkPtr): OSErr;
  234.     {$IFC NOT GENERATINGCFM}
  235.     INLINE $303C, $0B07, $A82F;
  236.     {$ENDC}
  237. FUNCTION DBExec(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  238.     {$IFC NOT GENERATINGCFM}
  239.     INLINE $303C, $0408, $A82F;
  240.     {$ENDC}
  241. FUNCTION DBState(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  242.     {$IFC NOT GENERATINGCFM}
  243.     INLINE $303C, $0409, $A82F;
  244.     {$ENDC}
  245. FUNCTION DBGetErr(sessID: LONGINT; VAR err1: LONGINT; VAR err2: LONGINT; VAR item1: Str255; VAR item2: Str255; VAR errorMsg: Str255; asyncPB: DBAsyncParmBlkPtr): OSErr;
  246.     {$IFC NOT GENERATINGCFM}
  247.     INLINE $303C, $0E0A, $A82F;
  248.     {$ENDC}
  249. FUNCTION DBBreak(sessID: LONGINT; abort: BOOLEAN; asyncPB: DBAsyncParmBlkPtr): OSErr;
  250.     {$IFC NOT GENERATINGCFM}
  251.     INLINE $303C, $050B, $A82F;
  252.     {$ENDC}
  253. FUNCTION DBGetItem(sessID: LONGINT; timeout: LONGINT; VAR dataType: DBType; VAR len: INTEGER; VAR places: INTEGER; VAR flags: INTEGER; buffer: UNIV Ptr; asyncPB: DBAsyncParmBlkPtr): OSErr;
  254.     {$IFC NOT GENERATINGCFM}
  255.     INLINE $303C, $100C, $A82F;
  256.     {$ENDC}
  257. FUNCTION DBUnGetItem(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  258.     {$IFC NOT GENERATINGCFM}
  259.     INLINE $303C, $040D, $A82F;
  260.     {$ENDC}
  261. FUNCTION DBKill(asyncPB: DBAsyncParmBlkPtr): OSErr;
  262.     {$IFC NOT GENERATINGCFM}
  263.     INLINE $303C, $020E, $A82F;
  264.     {$ENDC}
  265. FUNCTION DBGetNewQuery(queryID: INTEGER; VAR query: QueryHandle): OSErr;
  266.     {$IFC NOT GENERATINGCFM}
  267.     INLINE $303C, $030F, $A82F;
  268.     {$ENDC}
  269. FUNCTION DBDisposeQuery(query: QueryHandle): OSErr;
  270.     {$IFC NOT GENERATINGCFM}
  271.     INLINE $303C, $0210, $A82F;
  272.     {$ENDC}
  273. FUNCTION DBStartQuery(VAR sessID: LONGINT; query: QueryHandle; statusProc: DBStatusUPP; asyncPB: DBAsyncParmBlkPtr): OSErr;
  274.     {$IFC NOT GENERATINGCFM}
  275.     INLINE $303C, $0811, $A82F;
  276.     {$ENDC}
  277. FUNCTION DBGetQueryResults(sessID: LONGINT; VAR results: ResultsRecord; timeout: LONGINT; statusProc: DBStatusUPP; asyncPB: DBAsyncParmBlkPtr): OSErr;
  278.     {$IFC NOT GENERATINGCFM}
  279.     INLINE $303C, $0A12, $A82F;
  280.     {$ENDC}
  281. FUNCTION DBResultsToText(VAR results: ResultsRecord; VAR theText: Handle): OSErr;
  282.     {$IFC NOT GENERATINGCFM}
  283.     INLINE $303C, $0413, $A82F;
  284.     {$ENDC}
  285. FUNCTION DBInstallResultHandler(dataType: DBType; theHandler: DBResultHandlerUPP; isSysHandler: BOOLEAN): OSErr;
  286.     {$IFC NOT GENERATINGCFM}
  287.     INLINE $303C, $0514, $A82F;
  288.     {$ENDC}
  289. FUNCTION DBRemoveResultHandler(dataType: DBType): OSErr;
  290.     {$IFC NOT GENERATINGCFM}
  291.     INLINE $303C, $0215, $A82F;
  292.     {$ENDC}
  293. FUNCTION DBGetResultHandler(dataType: DBType; VAR theHandler: DBResultHandlerUPP; getSysHandler: BOOLEAN): OSErr;
  294.     {$IFC NOT GENERATINGCFM}
  295.     INLINE $303C, $0516, $A82F;
  296.     {$ENDC}
  297. FUNCTION DBIdle: OSErr;
  298.     {$IFC NOT GENERATINGCFM}
  299.     INLINE $303C, $00FF, $A82F;
  300.     {$ENDC}
  301. {$ENDC}
  302. {$ALIGN RESET}
  303. {$POP}
  304.  
  305. {$SETC UsingIncludes := DatabaseAccessIncludes}
  306.  
  307. {$ENDC} {__DATABASEACCESS__}
  308.  
  309. {$IFC NOT UsingIncludes}
  310.  END.
  311. {$ENDC}
  312.